ஜாவாஸ்கிரிப்ட் மெமோசேஷன் முறைகள்: கேச்சிங் உத்திகள் மற்றும் செயல்திறன் மேம்பாடுகள்

மென்பொருள் மேம்பாட்டுத் துறையில், செயல்திறன் மிகவும் முக்கியமானது. ஜாவாஸ்கிரிப்ட், ஒரு பல்துறை மொழியாக, ஃப்ரண்ட்-எண்ட் வெப் டெவலப்மெண்ட் முதல் Node.js உடன் சர்வர்-சைட் பயன்பாடுகள் வரை பல்வேறு சூழல்களில் பயன்படுத்தப்படுகிறது, இது சீரான மற்றும் திறமையான செயல்பாட்டை உறுதிசெய்ய அடிக்கடி மேம்படுத்தல் தேவைப்படுகிறது. குறிப்பிட்ட சூழ்நிலைகளில் செயல்திறனை கணிசமாக மேம்படுத்தக்கூடிய ஒரு சக்திவாய்ந்த நுட்பம் மெமோசேஷன் ஆகும்.

மெமோசேஷன் என்பது ஒரு மேம்படுத்தல் நுட்பமாகும், இது முதன்மையாக விலை உயர்ந்த ஃபங்ஷன் அழைப்புகளின் முடிவுகளைச் சேமித்து, அதே உள்ளீடுகள் மீண்டும் ஏற்படும்போது சேமிக்கப்பட்ட முடிவைத் திருப்பி அனுப்புவதன் மூலம் கணினி நிரல்களை வேகப்படுத்தப் பயன்படுகிறது. சாராம்சத்தில், இது ஃபங்ஷன்களை குறிப்பாக இலக்காகக் கொண்ட ஒரு வகையான கேச்சிங் ஆகும். இந்த அணுகுமுறை குறிப்பாகப் பின்வரும் வகையான ஃபங்ஷன்களுக்குப் பயனுள்ளதாக இருக்கும்:

• தூய்மையானவை (Pure): பக்க விளைவுகள் இல்லாமல், அதன் உள்ளீட்டு மதிப்புகளால் மட்டுமே அதன் ரிட்டர்ன் மதிப்பு தீர்மானிக்கப்படும் ஃபங்ஷன்கள்.
• தீர்மானிக்கப்பட்டவை (Deterministic): ஒரே உள்ளீட்டிற்கு, ஃபங்ஷன் எப்போதும் ஒரே வெளியீட்டை உருவாக்கும்.
• விலை உயர்ந்தவை (Expensive): கணக்கீடுகள் கணக்கீட்டு ரீதியாக தீவிரமானவை அல்லது நேரத்தை எடுத்துக்கொள்ளும் ஃபங்ஷன்கள் (எ.கா., ரெக்கர்சிவ் ஃபங்ஷன்கள், சிக்கலான கணக்கீடுகள்).

இந்தக் கட்டுரை ஜாவாஸ்கிரிப்டில் உள்ள மெமோசேஷன் கருத்தை ஆராய்கிறது, பல்வேறு முறைகள், கேச்சிங் உத்திகள் மற்றும் அதன் செயலாக்கத்தின் மூலம் அடையக்கூடிய செயல்திறன் மேம்பாடுகளை ஆராய்கிறது. வெவ்வேறு சூழ்நிலைகளில் மெமோசேஷனை எவ்வாறு திறம்படப் பயன்படுத்துவது என்பதை விளக்க நடைமுறை எடுத்துக்காட்டுகளை நாங்கள் ஆராய்வோம்.

மெமோசேஷனைப் புரிந்துகொள்ளுதல்: முக்கிய கருத்து

அதன் மையத்தில், மெமோசேஷன் கேச்சிங் கொள்கையைப் பயன்படுத்துகிறது. ஒரு மெமோசேஷன் செய்யப்பட்ட ஃபங்ஷன் ஒரு குறிப்பிட்ட தொகுதி ஆர்க்யுமெண்ட்களுடன் அழைக்கப்படும்போது, அது முதலில் அந்த ஆர்க்யுமெண்ட்களுக்கான முடிவு ஏற்கனவே கணக்கிடப்பட்டு ஒரு கேச்சில் (பொதுவாக ஒரு ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் அல்லது மேப்) சேமிக்கப்பட்டுள்ளதா என்று சரிபார்க்கிறது. கேச்சில் முடிவு காணப்பட்டால், அது உடனடியாகத் திருப்பி அனுப்பப்படும். இல்லையெனில், ஃபங்ஷன் கணக்கீட்டைச் செய்கிறது, முடிவைக் கேச்சில் சேமித்து, பின்னர் அதைத் திருப்பி அனுப்புகிறது.

தேவையற்ற கணக்கீடுகளைத் தவிர்ப்பதில் முக்கிய நன்மை உள்ளது. ஒரு ஃபங்ஷன் ஒரே உள்ளீடுகளுடன் பல முறை அழைக்கப்பட்டால், மெமோசேஷன் செய்யப்பட்ட பதிப்பு கணக்கீட்டை ஒரு முறை மட்டுமே செய்கிறது. அடுத்தடுத்த அழைப்புகள் முடிவை நேரடியாக கேச்சிலிருந்து பெறுகின்றன, இது குறிப்பாக கணக்கீட்டு ரீதியாக விலை உயர்ந்த செயல்பாடுகளுக்கு குறிப்பிடத்தக்க செயல்திறன் மேம்பாடுகளை விளைவிக்கிறது.

ஜாவாஸ்கிரிப்டில் மெமோசேஷன் முறைகள்

ஜாவாஸ்கிரிப்டில் மெமோசேஷனை செயல்படுத்த பல முறைகளைப் பயன்படுத்தலாம். மிகவும் பொதுவான மற்றும் பயனுள்ள சிலவற்றை ஆராய்வோம்:

1. க்ளோசருடன் கூடிய அடிப்படை மெமோசேஷன்

இது மெமோசேஷனுக்கான மிகவும் அடிப்படையான அணுகுமுறையாகும். இது ஒரு க்ளோசரைப் பயன்படுத்தி ஃபங்ஷனின் ஸ்கோப்பிற்குள் ஒரு கேச்சை பராமரிக்கிறது. கேச் பொதுவாக ஒரு எளிய ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்டாக இருக்கும், அங்கு கீகள் ஃபங்ஷன் ஆர்க்யுமெண்ட்களைக் குறிக்கின்றன மற்றும் மதிப்புகள் அதனுடன் தொடர்புடைய முடிவுகளைக் குறிக்கின்றன.

function memoize(func) {
 const cache = {};
 return function(...args) {
 const key = JSON.stringify(args); // Create a unique key for the arguments
 if (cache[key]) {
 return cache[key]; // Return cached result
 } else {
 const result = func.apply(this, args); // Calculate the result
 cache[key] = result; // Store the result in the cache
 return result; // Return the result
 }
 };
}

// Example: Memoizing a factorial function
function factorial(n) {
 if (n <= 1) {
 return 1;
 }
 return n * factorial(n - 1);
}

const memoizedFactorial = memoize(factorial);

console.time('First call');
console.log(memoizedFactorial(5)); // Calculates and caches
console.timeEnd('First call');

console.time('Second call');
console.log(memoizedFactorial(5)); // Retrieves from cache
console.timeEnd('Second call');

விளக்கம்:

• `memoize` ஃபங்ஷன் ஒரு `func` ஃபங்ஷனை உள்ளீடாக எடுத்துக்கொள்கிறது.
• அது அதன் ஸ்கோப்பிற்குள் ஒரு `cache` ஆப்ஜெக்ட்டை உருவாக்குகிறது (ஒரு க்ளோசரைப் பயன்படுத்தி).
• இது அசல் ஃபங்ஷனைச் சுற்றியுள்ள ஒரு புதிய ஃபங்ஷனைத் திருப்பி அனுப்புகிறது.
• இந்த ராப்பர் ஃபங்ஷன், ஃபங்ஷன் ஆர்க்யுமெண்ட்களின் அடிப்படையில் `JSON.stringify(args)` ஐப் பயன்படுத்தி ஒரு தனித்துவமான கீயை உருவாக்குகிறது.
• `cache`-ல் `key` இருக்கிறதா என்று சரிபார்க்கிறது. இருந்தால், அது கேச் செய்யப்பட்ட மதிப்பைத் திருப்பி அனுப்புகிறது.
• `key` இல்லையென்றால், அது அசல் ஃபங்ஷனை அழைத்து, முடிவை `cache`-ல் சேமித்து, பின்னர் முடிவைத் திருப்பி அனுப்புகிறது.

குறைபாடுகள்:

• சிக்கலான ஆப்ஜெக்ட்களுக்கு `JSON.stringify` மெதுவாக இருக்கலாம்.
• வெவ்வேறு வரிசைகளில் ஆர்க்யுமெண்ட்களை ஏற்கும் ஃபங்ஷன்களுக்கு அல்லது ஒரே கீகள் ஆனால் வெவ்வேறு வரிசைகளைக் கொண்ட ஆப்ஜெக்ட்களுக்கு கீ உருவாக்குவது சிக்கலாக இருக்கலாம்.
• `JSON.stringify(NaN)` `null`-ஐத் திருப்பி அனுப்புவதால் `NaN`-ஐச் சரியாகக் கையாளாது.

2. தனிப்பயன் கீ ஜெனரேட்டருடன் மெமோசேஷன்

`JSON.stringify`-இன் வரம்புகளைக் கையாள, ஃபங்ஷனின் ஆர்க்யுமெண்ட்களின் அடிப்படையில் ஒரு தனித்துவமான கீயை உருவாக்கும் ஒரு தனிப்பயன் கீ ஜெனரேட்டர் ஃபங்ஷனை நீங்கள் உருவாக்கலாம். இது கேச் எப்படி அட்டவணைப்படுத்தப்படுகிறது என்பதில் அதிகக் கட்டுப்பாட்டை வழங்குகிறது மற்றும் சில சூழ்நிலைகளில் செயல்திறனை மேம்படுத்தலாம்.

function memoizeWithKey(func, keyGenerator) {
 const cache = {};
 return function(...args) {
 const key = keyGenerator(...args);
 if (cache[key]) {
 return cache[key];
 } else {
 const result = func.apply(this, args);
 cache[key] = result;
 return result;
 }
 };
}

// Example: Memoizing a function that adds two numbers
function add(a, b) {
 console.log('Calculating...');
 return a + b;
}

// Custom key generator for the add function
function addKeyGenerator(a, b) {
 return `${a}-${b}`;
}

const memoizedAdd = memoizeWithKey(add, addKeyGenerator);

console.log(memoizedAdd(2, 3)); // Calculates and caches
console.log(memoizedAdd(2, 3)); // Retrieves from cache
console.log(memoizedAdd(3, 2)); // Calculates and caches (different key)

விளக்கம்:

• இந்தப் முறை அடிப்படை மெமோசேஷனைப் போன்றது, ஆனால் இது ஒரு கூடுதல் ஆர்க்யுமென்டை ஏற்கிறது: `keyGenerator`.
• `keyGenerator` என்பது அசல் ஃபங்ஷனின் அதே ஆர்க்யுமெண்ட்களை எடுத்து ஒரு தனித்துவமான கீயைத் திருப்பி அனுப்பும் ஒரு ஃபங்ஷன்.
• இது குறிப்பாக சிக்கலான தரவு கட்டமைப்புகளுடன் பணிபுரியும் ஃபங்ஷன்களுக்கு, மிகவும் நெகிழ்வான மற்றும் திறமையான கீ உருவாக்கத்தை அனுமதிக்கிறது.

3. ஒரு மேப் உடன் மெமோசேஷன்

ஜாவாஸ்கிரிப்டில் உள்ள `Map` ஆப்ஜெக்ட், கேச் செய்யப்பட்ட முடிவுகளைச் சேமிக்க மிகவும் வலிமையான மற்றும் பல்துறை வழியை வழங்குகிறது. சாதாரண ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்களைப் போலல்லாமல், `Map` உங்களை ஆப்ஜெக்ட்கள் மற்றும் ஃபங்ஷன்கள் உட்பட எந்தத் தரவு வகையையும் கீகளாகப் பயன்படுத்த அனுமதிக்கிறது. இது ஆர்க்யுமெண்ட்களை ஸ்டிரிங்ஃபை செய்ய வேண்டிய அவசியத்தை நீக்கி, கீ உருவாக்கத்தை எளிதாக்குகிறது.

function memoizeWithMap(func) {
 const cache = new Map();
 return function(...args) {
 const key = args.join('|'); // Create a simple key (can be more sophisticated)
 if (cache.has(key)) {
 return cache.get(key);
 } else {
 const result = func.apply(this, args);
 cache.set(key, result);
 return result;
 }
 };
}

// Example: Memoizing a function that concatenates strings
function concatenate(str1, str2) {
 console.log('Concatenating...');
 return str1 + str2;
}

const memoizedConcatenate = memoizeWithMap(concatenate);

console.log(memoizedConcatenate('hello', 'world')); // Calculates and caches
console.log(memoizedConcatenate('hello', 'world')); // Retrieves from cache

விளக்கம்:

• இந்தப் முறை கேச்சை சேமிக்க ஒரு `Map` ஆப்ஜெக்ட்டைப் பயன்படுத்துகிறது.
• `Map` உங்களை எந்தத் தரவு வகையையும் கீகளாகப் பயன்படுத்த அனுமதிக்கிறது, ஆப்ஜெக்ட்கள் மற்றும் ஃபங்ஷன்கள் உட்பட, இது சாதாரண ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்களுடன் ஒப்பிடும்போது அதிக நெகிழ்வுத்தன்மையை வழங்குகிறது.
• `Map` ஆப்ஜெக்ட்டின் `has` மற்றும் `get` முறைகள் முறையே கேச் செய்யப்பட்ட மதிப்புகளைச் சரிபார்க்கவும் மீட்டெடுக்கவும் பயன்படுத்தப்படுகின்றன.

4. ரெக்கர்சிவ் மெமோசேஷன்

ரெக்கர்சிவ் ஃபங்ஷன்களை மேம்படுத்துவதில் மெமோசேஷன் மிகவும் பயனுள்ளதாக இருக்கும். இடைநிலை கணக்கீடுகளின் முடிவுகளை கேச் செய்வதன் மூலம், நீங்கள் தேவையற்ற கணக்கீடுகளைத் தவிர்க்கலாம் மற்றும் செயல்பாட்டு நேரத்தை கணிசமாகக் குறைக்கலாம்.

function memoizeRecursive(func) {
 const cache = {};
 function memoized(...args) {
 const key = String(args);
 if (cache[key]) {
 return cache[key];
 } else {
 cache[key] = func(memoized, ...args);
 return cache[key];
 }
 }
 return memoized;
}

// Example: Memoizing a Fibonacci sequence function
function fibonacci(memoized, n) {
 if (n <= 1) {
 return n;
 }
 return memoized(n - 1) + memoized(n - 2);
}

const memoizedFibonacci = memoizeRecursive(fibonacci);

console.time('First call');
console.log(memoizedFibonacci(10)); // Calculates and caches
console.timeEnd('First call');

console.time('Second call');
console.log(memoizedFibonacci(10)); // Retrieves from cache
console.timeEnd('Second call');

விளக்கம்:

• `memoizeRecursive` ஃபங்ஷன் ஒரு `func` ஃபங்ஷனை உள்ளீடாக எடுத்துக்கொள்கிறது.
• அது அதன் ஸ்கோப்பிற்குள் ஒரு `cache` ஆப்ஜெக்ட்டை உருவாக்குகிறது.
• இது அசல் ஃபங்ஷனைச் சுற்றியுள்ள ஒரு புதிய `memoized` ஃபங்ஷனைத் திருப்பி அனுப்புகிறது.
• `memoized` ஃபங்ஷன், கொடுக்கப்பட்ட ஆர்க்யுமெண்ட்களுக்கான முடிவு ஏற்கனவே கேச்சில் உள்ளதா என்று சரிபார்க்கிறது. இருந்தால், அது கேச் செய்யப்பட்ட மதிப்பைத் திருப்பி அனுப்புகிறது.
• முடிவு கேச்சில் இல்லை என்றால், அது அசல் ஃபங்ஷனை `memoized` ஃபங்ஷனுடன் முதல் ஆர்க்யுமென்டாக அழைக்கிறது. இது அசல் ஃபங்ஷனை அதன் மெமோசேஷன் செய்யப்பட்ட பதிப்பை ரெக்கர்சிவாக அழைக்க அனுமதிக்கிறது.
• பின்னர் முடிவு கேச்சில் சேமிக்கப்பட்டு திருப்பி அனுப்பப்படுகிறது.

5. கிளாஸ்-அடிப்படையிலான மெமோசேஷன்

ஆப்ஜெக்ட்-ஓரியண்டட் நிரலாக்கத்திற்கு, மெத்தட்களின் முடிவுகளை கேச் செய்ய ஒரு கிளாஸுக்குள் மெமோசேஷனை செயல்படுத்தலாம். இது அடிக்கடி ஒரே ஆர்க்யுமெண்ட்களுடன் அழைக்கப்படும் கணக்கீட்டு ரீதியாக விலை உயர்ந்த மெத்தட்களுக்கு பயனுள்ளதாக இருக்கும்.

class MemoizedClass {
 constructor() {
 this.cache = {};
 }

 memoizeMethod(func) {
 return (...args) => {
 const key = JSON.stringify(args);
 if (this.cache[key]) {
 return this.cache[key];
 } else {
 const result = func.apply(this, args);
 this.cache[key] = result;
 return result;
 }
 };
 }

 // Example: Memoizing a method that calculates the power of a number
 power(base, exponent) {
 console.log('Calculating power...');
 return Math.pow(base, exponent);
 }
}

const memoizedInstance = new MemoizedClass();
const memoizedPower = memoizedInstance.memoizeMethod(memoizedInstance.power);

console.log(memoizedPower(2, 3)); // Calculates and caches
console.log(memoizedPower(2, 3)); // Retrieves from cache

விளக்கம்:

• `MemoizedClass` அதன் கன்ஸ்ட்ரக்டரில் ஒரு `cache` பண்பை வரையறுக்கிறது.
• `memoizeMethod` ஒரு ஃபங்ஷனை உள்ளீடாக எடுத்து, அந்த ஃபங்ஷனின் மெமோசேஷன் செய்யப்பட்ட பதிப்பைத் திருப்பி அனுப்புகிறது, இது கிளாஸின் `cache`-ல் முடிவுகளைச் சேமிக்கிறது.
• இது ஒரு கிளாஸின் குறிப்பிட்ட மெத்தட்களைத் தேர்ந்தெடுத்து மெமோசேஷன் செய்ய உங்களை அனுமதிக்கிறது.

கேச்சிங் உத்திகள்

அடிப்படை மெமோசேஷன் முறைகளுக்கு அப்பால், கேச் நடத்தையை மேம்படுத்தவும் அதன் அளவை நிர்வகிக்கவும் வெவ்வேறு கேச்சிங் உத்திகளைப் பயன்படுத்தலாம். இந்த உத்திகள் கேச் திறமையாக இருப்பதையும், அதிகப்படியான நினைவகத்தை நுகராமல் இருப்பதையும் உறுதிசெய்ய உதவுகின்றன.

1. குறைந்தபட்சம் சமீபத்தில் பயன்படுத்தப்பட்டது (LRU) கேச்

கேச் அதன் அதிகபட்ச அளவை அடையும்போது LRU கேச் குறைந்தபட்சம் சமீபத்தில் பயன்படுத்தப்பட்ட உருப்படிகளை வெளியேற்றுகிறது. இந்த உத்தி மிகவும் அடிக்கடி அணுகப்படும் தரவு கேச்சில் இருப்பதை உறுதிசெய்கிறது, அதே நேரத்தில் குறைவாகப் பயன்படுத்தப்படும் தரவு நிராகரிக்கப்படுகிறது.

class LRUCache {
 constructor(capacity) {
 this.capacity = capacity;
 this.cache = new Map();
 }

 get(key) {
 if (this.cache.has(key)) {
 const value = this.cache.get(key);
 this.cache.delete(key); // Re-insert to mark as recently used
 this.cache.set(key, value);
 return value;
 } else {
 return undefined;
 }
 }

 put(key, value) {
 if (this.cache.has(key)) {
 this.cache.delete(key);
 }
 this.cache.set(key, value);
 if (this.cache.size > this.capacity) {
 // Remove the least recently used item
 const firstKey = this.cache.keys().next().value;
 this.cache.delete(firstKey);
 }
 }
}

// Example usage:
const lruCache = new LRUCache(3); // Capacity of 3

lruCache.put('a', 1);
lruCache.put('b', 2);
lruCache.put('c', 3);

console.log(lruCache.get('a')); // 1 (moves 'a' to the end)

lruCache.put('d', 4); // 'b' is evicted

console.log(lruCache.get('b')); // undefined
console.log(lruCache.get('a')); // 1
console.log(lruCache.get('c')); // 3
console.log(lruCache.get('d')); // 4

விளக்கம்:

• கேச்சை சேமிக்க ஒரு `Map`-ஐப் பயன்படுத்துகிறது, இது செருகும் வரிசையை பராமரிக்கிறது.
• `get(key)` மதிப்பை மீட்டெடுத்து, கீ-வேல்யூ ஜோடியை மீண்டும் செருகுவதன் மூலம் அதை சமீபத்தில் பயன்படுத்தப்பட்டதாகக் குறிக்கிறது.
• `put(key, value)` கீ-வேல்யூ ஜோடியைச் செருகுகிறது. கேச் நிரம்பியிருந்தால், குறைந்தபட்சம் சமீபத்தில் பயன்படுத்தப்பட்ட உருப்படி (`Map`-இல் முதல் உருப்படி) அகற்றப்படும்.

2. குறைந்தபட்சம் அடிக்கடி பயன்படுத்தப்பட்டது (LFU) கேச்

கேச் நிரம்பியிருக்கும்போது LFU கேச் குறைந்தபட்சம் அடிக்கடி பயன்படுத்தப்படும் உருப்படிகளை வெளியேற்றுகிறது. இந்த உத்தி அடிக்கடி அணுகப்படும் தரவுகளுக்கு முன்னுரிமை அளிக்கிறது, அது கேச்சில் இருப்பதை உறுதிசெய்கிறது.

class LFUCache {
 constructor(capacity) {
 this.capacity = capacity;
 this.cache = new Map();
 this.frequencies = new Map();
 this.minFrequency = 0;
 }

 get(key) {
 if (!this.cache.has(key)) {
 return undefined;
 }

 const frequency = this.frequencies.get(key);
 this.frequencies.set(key, frequency + 1);
 return this.cache.get(key);
 }

 put(key, value) {
 if (this.capacity <= 0) {
 return;
 }

 if (this.cache.has(key)) {
 this.cache.set(key, value);
 this.get(key);
 return;
 }

 if (this.cache.size >= this.capacity) {
 this.evict();
 }

 this.cache.set(key, value);
 this.frequencies.set(key, 1);
 this.minFrequency = 1;
 }

 evict() {
 let minFreq = Infinity;
 for (const frequency of this.frequencies.values()) {
 minFreq = Math.min(minFreq, frequency);
 }

 const keysToRemove = [];
 this.frequencies.forEach((freq, key) => {
 if (freq === minFreq) {
 keysToRemove.push(key);
 }
 });

 const keyToRemove = keysToRemove[0];
 this.cache.delete(keyToRemove);
 this.frequencies.delete(keyToRemove);
 }
}

// Example usage:
const lfuCache = new LFUCache(2);

lfuCache.put('a', 1);
lfuCache.put('b', 2);
console.log(lfuCache.get('a')); // 1, frequency(a) = 2
lfuCache.put('c', 3); // evicts 'b' because frequency(b) = 1
console.log(lfuCache.get('b')); // undefined
console.log(lfuCache.get('a')); // 1, frequency(a) = 3
console.log(lfuCache.get('c')); // 3, frequency(c) = 2

விளக்கம்:

• இரண்டு `Map` ஆப்ஜெக்ட்களைப் பயன்படுத்துகிறது: `cache` கீ-வேல்யூ ஜோடிகளைச் சேமிக்கவும் மற்றும் `frequencies` ஒவ்வொரு கீயின் அணுகல் அதிர்வெண்ணைச் சேமிக்கவும்.
• `get(key)` மதிப்பை மீட்டெடுத்து, அதிர்வெண் எண்ணிக்கையை அதிகரிக்கிறது.
• `put(key, value)` கீ-வேல்யூ ஜோடியைச் செருகுகிறது. கேச் நிரம்பியிருந்தால், அது குறைந்தபட்சம் அடிக்கடி பயன்படுத்தப்படும் உருப்படியை வெளியேற்றுகிறது.
• `evict()` குறைந்தபட்ச அதிர்வெண் எண்ணிக்கையைக் கண்டுபிடித்து, தொடர்புடைய கீ-வேல்யூ ஜோடியை `cache` மற்றும் `frequencies` இரண்டிலிருந்தும் நீக்குகிறது.

3. நேரம்-அடிப்படையிலான காலாவதி

இந்த உத்தி ஒரு குறிப்பிட்ட காலத்திற்குப் பிறகு கேச் செய்யப்பட்ட உருப்படிகளை செல்லாததாக்குகிறது. காலப்போக்கில் பழையதாக அல்லது காலாவதியானதாக மாறும் தரவுகளுக்கு இது பயனுள்ளதாக இருக்கும். எடுத்துக்காட்டாக, சில நிமிடங்களுக்கு மட்டுமே செல்லுபடியாகும் API பதில்களை கேச் செய்வது.

function memoizeWithExpiration(func, ttl) {
 const cache = new Map();
 return function(...args) {
 const key = JSON.stringify(args);
 const cached = cache.get(key);

 if (cached && cached.expiry > Date.now()) {
 return cached.value;
 } else {
 const result = func.apply(this, args);
 cache.set(key, { value: result, expiry: Date.now() + ttl });
 return result;
 }
 };
}

// Example: Memoizing a function with a 5-second expiration time
function getDataFromAPI(endpoint) {
 console.log(`Fetching data from ${endpoint}...`);
 // Simulate an API call with a delay
 return new Promise(resolve => {
 setTimeout(() => {
 resolve(`Data from ${endpoint}`);
 }, 1000);
 });
}

const memoizedGetData = memoizeWithExpiration(getDataFromAPI, 5000); // TTL: 5 seconds

async function testExpiration() {
 console.log(await memoizedGetData('/users')); // Fetches and caches
 console.log(await memoizedGetData('/users')); // Retrieves from cache

 setTimeout(async () => {
 console.log(await memoizedGetData('/users')); // Fetches again after 5 seconds
 }, 6000);
}

testExpiration();

விளக்கம்:

• `memoizeWithExpiration` ஃபங்ஷன் ஒரு `func` ஃபங்ஷனையும் ஒரு நேர-வாழ்க்கை (TTL) மதிப்பையும் மில்லி விநாடிகளில் உள்ளீடாக எடுத்துக்கொள்கிறது.
• இது கேச் செய்யப்பட்ட மதிப்பை ஒரு காலாவதி நேர முத்திரையுடன் சேமிக்கிறது.
• கேச் செய்யப்பட்ட மதிப்பைத் திருப்பி அனுப்புவதற்கு முன், காலாவதி நேர முத்திரை இன்னும் எதிர்காலத்தில் உள்ளதா என்று சரிபார்க்கிறது. இல்லையென்றால், அது கேச்சை செல்லாததாக்கி, தரவை மீண்டும் பெறுகிறது.

செயல்திறன் மேம்பாடுகள் மற்றும் பரிசீலனைகள்

மெமோசேஷன் செயல்திறனை கணிசமாக மேம்படுத்த முடியும், குறிப்பாக ஒரே உள்ளீடுகளுடன் மீண்டும் மீண்டும் அழைக்கப்படும் கணக்கீட்டு ரீதியாக விலை உயர்ந்த ஃபங்ஷன்களுக்கு. செயல்திறன் மேம்பாடுகள் பின்வரும் சூழ்நிலைகளில் மிகவும் உச்சரிக்கப்படுகின்றன:

• ரெக்கர்சிவ் ஃபங்ஷன்கள்: மெமோசேஷன் ரெக்கர்சிவ் அழைப்புகளின் எண்ணிக்கையை வியத்தகு முறையில் குறைக்கலாம், இது அதிவேக செயல்திறன் மேம்பாடுகளுக்கு வழிவகுக்கும்.
• ஒன்றோடொன்று மேலெழுதும் துணைப் பிரச்சனைகளைக் கொண்ட ஃபங்ஷன்கள்: துணைப் பிரச்சனைகளின் முடிவுகளைச் சேமித்து, தேவைப்படும்போது அவற்றை மீண்டும் பயன்படுத்துவதன் மூலம் மெமோசேஷன் தேவையற்ற கணக்கீடுகளைத் தவிர்க்கலாம்.
• அடிக்கடி ஒரே மாதிரியான உள்ளீடுகளைக் கொண்ட ஃபங்ஷன்கள்: ஒவ்வொரு தனித்துவமான உள்ளீடுகளுக்கும் ஃபங்ஷன் ஒரு முறை மட்டுமே செயல்படுத்தப்படுவதை மெமோசேஷன் உறுதி செய்கிறது.

இருப்பினும், மெமோசேஷனைப் பயன்படுத்தும்போது பின்வரும் சமரசங்களைக் கருத்தில் கொள்வது அவசியம்:

• நினைவக நுகர்வு: மெமோசேஷன் ஃபங்ஷன் அழைப்புகளின் முடிவுகளைச் சேமிப்பதால் நினைவகப் பயன்பாட்டை அதிகரிக்கிறது. இது அதிக எண்ணிக்கையிலான சாத்தியமான உள்ளீடுகளைக் கொண்ட ஃபங்ஷன்களுக்கு அல்லது வரையறுக்கப்பட்ட நினைவக வளங்களைக் கொண்ட பயன்பாடுகளுக்கு ஒரு கவலையாக இருக்கலாம்.
• கேச் செல்லாததாக்குதல்: அடிப்படையான தரவு மாறினால், கேச் செய்யப்பட்ட முடிவுகள் பழையதாகிவிடும். கேச் தரவுகளுடன் சீராக இருப்பதை உறுதிசெய்ய, ஒரு கேச் செல்லாததாக்கும் உத்தியைச் செயல்படுத்துவது முக்கியம்.
• சிக்கலானது: மெமோசேஷனை செயல்படுத்துவது குறியீட்டிற்கு சிக்கலைச் சேர்க்கலாம், குறிப்பாக சிக்கலான கேச்சிங் உத்திகளுக்கு. மெமோசேஷனைப் பயன்படுத்துவதற்கு முன், குறியீட்டின் சிக்கலான தன்மை மற்றும் பராமரிப்புத்தன்மையைக் கவனமாகப் பரிசீலிப்பது அவசியம்.

நடைமுறை எடுத்துக்காட்டுகள் மற்றும் பயன்பாட்டு வழக்குகள்

செயல்திறனை மேம்படுத்த மெமோசேஷனைப் பரந்த அளவிலான சூழ்நிலைகளில் பயன்படுத்தலாம். இங்கே சில நடைமுறை எடுத்துக்காட்டுகள்:

• ஃப்ரண்ட்-எண்ட் வெப் டெவலப்மெண்ட்: ஜாவாஸ்கிரிப்டில் விலை உயர்ந்த கணக்கீடுகளை மெமோசேஷன் செய்வது வலைப் பயன்பாடுகளின் பதிலளிக்கும் தன்மையை மேம்படுத்தும். எடுத்துக்காட்டாக, சிக்கலான DOM கையாளுதல்களைச் செய்யும் அல்லது லேஅவுட் பண்புகளைக் கணக்கிடும் ஃபங்ஷன்களை நீங்கள் மெமோசேஷன் செய்யலாம்.
• சர்வர்-சைட் பயன்பாடுகள்: தரவுத்தள வினவல்கள் அல்லது API அழைப்புகளின் முடிவுகளை கேச் செய்ய மெமோசேஷனைப் பயன்படுத்தலாம், இது சர்வரில் உள்ள சுமைகளைக் குறைத்து, பதிலளிப்பு நேரங்களை மேம்படுத்துகிறது.
• தரவு பகுப்பாய்வு: இடைநிலை கணக்கீடுகளின் முடிவுகளை கேச் செய்வதன் மூலம் மெமோசேஷன் தரவு பகுப்பாய்வு பணிகளை வேகப்படுத்த முடியும். எடுத்துக்காட்டாக, புள்ளிவிவர பகுப்பாய்வு அல்லது இயந்திர கற்றல் அல்காரிதம்களைச் செய்யும் ஃபங்ஷன்களை நீங்கள் மெமோசேஷன் செய்யலாம்.
• விளையாட்டு மேம்பாடு: மோதல் கண்டறிதல் அல்லது பாதை கண்டறிதல் போன்ற அடிக்கடி பயன்படுத்தப்படும் கணக்கீடுகளின் முடிவுகளை கேச் செய்வதன் மூலம் விளையாட்டு செயல்திறனை மேம்படுத்த மெமோசேஷனைப் பயன்படுத்தலாம்.

முடிவுரை

மெமோசேஷன் என்பது ஜாவாஸ்கிரிப்ட் பயன்பாடுகளின் செயல்திறனை கணிசமாக மேம்படுத்தக்கூடிய ஒரு சக்திவாய்ந்த மேம்படுத்தல் நுட்பமாகும். விலை உயர்ந்த ஃபங்ஷன் அழைப்புகளின் முடிவுகளை கேச் செய்வதன் மூலம், நீங்கள் தேவையற்ற கணக்கீடுகளைத் தவிர்த்து, செயல்பாட்டு நேரத்தைக் குறைக்கலாம். இருப்பினும், செயல்திறன் மேம்பாடுகள் மற்றும் நினைவக நுகர்வு, கேச் செல்லாததாக்குதல் மற்றும் குறியீட்டின் சிக்கலானது ஆகியவற்றுக்கு இடையேயான சமரசங்களைக் கவனமாகப் பரிசீலிப்பது அவசியம். வெவ்வேறு மெமோசேஷன் முறைகள் மற்றும் கேச்சிங் உத்திகளைப் புரிந்துகொள்வதன் மூலம், உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டை மேம்படுத்தவும் உயர் செயல்திறன் கொண்ட பயன்பாடுகளை உருவாக்கவும் மெமோசேஷனை திறம்படப் பயன்படுத்தலாம்.